from datetime import datetime
import Levenshtein


class SQLProcessing:
    @staticmethod
    def ListToFields(fields: list):
        fields = str(fields).strip("[")
        fields = fields.strip("]")
        fields = fields.replace("\'", "")
        fields = fields.replace("\"", "")
        return fields


class Date:
    @staticmethod
    def GetTimeNow():
        formatted_now = datetime.now().strftime("%Y-%m-%d")
        return formatted_now

    @staticmethod
    def StringToDate(str_date, formation):
        result = datetime.strptime(str_date, "%Y-%m-%d %H:%M:%S").strftime(formation)
        return result


class Serializer:
    """自定义序列化器"""

    @staticmethod
    def ListOrTupleToDict(keys, values):
        """
        Args:
            keys: 传入键值
            values: 传入对应长度的值
        Returns:
            返回一个字典
        """
        if len(keys) != len(values):
            return {}
        return dict(zip(keys, values))


class SearchData:
    """数据搜索工具类"""

    @staticmethod
    def in_search(dict_list, pattern):
        """
        使用 `in` 进行精确匹配。返回包含匹配项的字典。

        Args:
            dict_list (list of dict): 需要搜索的字典列表。
            pattern (str): 需要匹配的模式。

        Returns:
            list of dict: 包含至少一个匹配项的字典列表。
        """
        pattern = pattern.lower()
        results = []
        for d in dict_list:
            if any(pattern in str(k).lower() or pattern in str(v).lower() for k, v in d.items()):
                results.append(d)
        return results

    @staticmethod
    def levenshtein_fuzzy_search(dict_list, pattern, max_distance=2):
        """
        使用 Levenshtein 距离进行模糊匹配。返回包含匹配项的字典，其中 Levenshtein 距离在指定的最大距离范围内。

        Args:
            dict_list (list of dict): 需要搜索的字典列表。
            pattern (str): 需要匹配的模式。
            max_distance (int): 允许的最大 Levenshtein 距离。

        Returns:
            list of dict: 包含至少一个匹配项的字典列表，匹配项的 Levenshtein 距离在允许范围内。
        """
        pattern = pattern.lower()
        results = []
        for d in dict_list:
            if any(Levenshtein.distance(str(k).lower(), pattern) <= max_distance or Levenshtein.distance(str(v).lower(),
                                                                                                         pattern) <= max_distance
                   for k, v in d.items()):
                results.append(d)
        return results

    @staticmethod
    def combined_search(dict_list, pattern, max_distance=2):
        """
        结合精确匹配和模糊匹配进行查询。返回包含匹配项的字典，匹配项可以是精确匹配或在 Levenshtein 距离允许范围内的模糊匹配。

        Args:
            dict_list (list of dict): 需要搜索的字典列表。
            pattern (str): 需要匹配的模式。
            max_distance (int): 允许的最大 Levenshtein 距离。

        Returns:
            list of dict: 包含至少一个匹配项的字典列表，匹配项可以是精确匹配或模糊匹配。
        """
        # 精确匹配
        exact_matches = SearchData.in_search(dict_list, pattern)
        if exact_matches:
            return exact_matches

        # 模糊匹配
        return SearchData.levenshtein_fuzzy_search(dict_list, pattern, max_distance)

